home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / cppcom.com / UART.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-14  |  9.7 KB  |  454 lines
  1. /***************************************************************************
  2. These C++ classes are copyright 1990, by William Herrera.
  3. All those who put this code or its derivatives in a commercial product MUST
  4. mention this copyright in their documentation for users of the products in
  5. which this code or its derivative classes are used.  Otherwise, this code
  6. may be freely distributed and freely used for any purpose.
  7.  
  8. Enhancements: 1991 by David Orme
  9.     *  General cleanup.
  10.             - I/O now takes advantage of C++ overloading.
  11.             - Serial port I/O functionality now only in Serial class.
  12.             - Modem functionality now only in Modem class.
  13.     *  Possible to easily implement file Xfr prots now.
  14.     *  CCITT CRC-16 class added                            -- 2-20-1991
  15.     *  BIOS Timer class added                                -- 2-22-1991
  16.     *  Optional timeout on all input routines added    -- 2-25-1991
  17.  
  18. ***************************************************************************/
  19.  
  20. // File uart.cpp, class definitions for the uart class.
  21. // By William Herrera.
  22.  
  23. // See your modem manual (I used MultiTech's) or the IBM Technical
  24. // reference manual for more information on the 8250 UART used in the PC.
  25.  
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28.  
  29.  
  30. #include "uart.hpp"
  31.  
  32.  
  33. // C++ 2.0 requires that static data members be declared globally
  34.  
  35. char uart::old_intmask[NUM_PORTS];
  36. char uart::old_MCR[NUM_PORTS];
  37. char uart::old_IER[NUM_PORTS];
  38.  
  39. const int uart::portvector_num[NUM_PORTS] = { 0xC, 0xB, 0xC, 0xB };
  40.  
  41. const char uart::intmaskbit[NUM_PORTS] = { 0x10, 0x08, 0x10, 0x08 };
  42.  
  43. #ifdef __TURBOC__
  44. DRIVER uart::old_driver[NUM_PORTS] = { NULL, NULL, NULL, NULL };
  45. #else ifdef __ZTC__
  46. void far * uart::old_driver[NUM_PORTS] = { NULL, NULL, NULL, NULL };
  47. #endif
  48.  
  49. uart::uart() { ; }
  50.  
  51. uart::~uart() { ; }
  52.  
  53.  
  54. // the following function sets up the PC for interrupt-driven serial
  55. // communications through the UART.  Returns 0 for success, -1 for
  56. // port disallowed, -2 for uart interrupts not resettable.
  57. int uart::RegisterDriver(int portnum, DRIVER driv)
  58. {
  59.     int retval;
  60.     if(
  61.         (portnum < 1) || (portnum > NUM_PORTS) || 
  62.             (old_driver[portnum - 1] != NULL) )
  63.     {
  64.         fputs("uart::RegisterDriver() cannot set port requested.\n", 
  65.                 stderr);
  66.         retval = -1;
  67.     }
  68.     else
  69.     {
  70.         disable();
  71.         // Hardware interrupts off til we change the settings.
  72.         // Make sure DLAB of LSR is 0 to allow access to IER and MCR.
  73.         SetLCR_DLAB(false);
  74.         // Save old IER and MCR.
  75.         old_IER[portnum -1] = GetIER();
  76.         old_MCR[portnum- 1] = GetMCR();
  77.         // Then check the UART for accessibility.
  78.         SetIER(0);
  79.         if(GetIER() != 0)
  80.         {
  81.             fputs("uart error:  unable to reset IER\n", stderr);
  82.             retval = -2;
  83.         }
  84.         else
  85.         {
  86.             // save the old interrupt mask.
  87.             old_intmask[portnum - 1] = inportb(0x21);
  88.                 
  89.             // reset vector to point to our handler.
  90. #ifdef __TURBOC__
  91.             old_driver[portnum - 1] = getvect(portvector_num[portnum - 1]);
  92.             setvect(portvector_num[portnum - 1], driv);
  93. #else ifdef __ZTC__
  94.             unsigned int iseg, ioff;
  95.             int_getvector(portvector_num[portnum - 1], &ioff, &iseg);
  96.             old_driver[portnum - 1] = MK_FP(iseg, ioff);
  97.             int_intercept(portvector_num[portnum - 1], driv, 0);
  98. #endif
  99.             SetMCR(9);    // turn on DTR and interrupts by modem (1|8).
  100.             SetIER(13);    // turn on data ready, line, modem ints (1|4|8).
  101.  
  102.             // Now enable controller for serial port interrupts.
  103.             outportb( 0x21, (inportb(0x21) & ~(intmaskbit[portnum - 1])) );
  104.  
  105.             // set speed to a default baud rate of 19200.
  106.             SetSpeed(19200);
  107.             // Set port to default parameters of 8 data, 1 stop, no parity.
  108.             SetParity(NOPAR);
  109.             SetWordLength(8);
  110.             SetStopBits(1);
  111.  
  112.             retval = 0;
  113.         }
  114.         enable();
  115.     }
  116.     return retval;
  117. }
  118.  
  119. // This function resets the interrupt controller and UART and 
  120. // generally cleans up after the RegisterDriver function.
  121. // Returns 0 on success, -1 on port not restorable.
  122. int uart::RestoreDriver(int portnum)
  123. {
  124.     int retval;
  125.     if( (portnum < 1) || (portnum > NUM_PORTS) || 
  126.             (old_driver[portnum - 1] == NULL) )
  127.     {
  128.         fputs("UART Error:  Cannot restore port.\n", stderr);
  129.         retval = -1;
  130.     }
  131.     else 
  132.     {
  133.         // reset the interrupt vector.
  134.         disable();
  135. #ifdef __TURBOC__
  136.         setvect(portvector_num[portnum - 1], old_driver[portnum - 1]);
  137. #else ifdef __ZTC__
  138.         int_restore(portvector_num[portnum - 1]);    
  139. #endif
  140.         // reset the i8259 mask to its original state.
  141.         outportb(0x21, old_intmask[portnum - 1]);
  142.         // reset UART registers.
  143.         SetIER(old_IER[portnum -1]);    
  144.         SetMCR(old_MCR[portnum - 1]);
  145.         enable();
  146.         old_driver[portnum - 1] = NULL;
  147.         retval = 0;
  148.     }
  149.     return retval;
  150. }
  151.  
  152. char uart::GetLCR()
  153. {
  154.     return inportb(LCR());
  155. }
  156.  
  157. char uart::GetDLL()
  158. {
  159.     return inportb(DLL());
  160. }
  161.  
  162. char uart::GetDLM()
  163. {     
  164.     return inportb(DLM());
  165. }
  166.  
  167. char uart::GetLSR()
  168. {      
  169.     return inportb(LSR());
  170. }
  171.  
  172. char uart::GetMCR()
  173. {   
  174.     return inportb(MCR());
  175. }
  176.  
  177. char uart::GetMSR()
  178. {    
  179.     return inportb(MSR());
  180. }
  181.  
  182. char uart::GetRBR()
  183. {    
  184.     return inportb(RBR());
  185. }
  186.  
  187. char uart::GetIER()
  188. {    
  189.     return inportb(IER());
  190. }
  191.  
  192. char uart::GetIIR()
  193. {
  194.     return inportb(IIR());
  195. }
  196.  
  197. boolean uart::GetLSR_THRE()
  198. {
  199.     return (GetLSR() & 32) ? true : false;
  200. }
  201.  
  202. void uart::SetLCR(char byte)
  203. {
  204.     outportb(LCR(), byte);
  205. }
  206.  
  207. void uart::SetDLL(char byte)
  208. {
  209.     outportb(DLL(), byte);
  210. }
  211.  
  212. void uart::SetDLM(char byte)
  213. {
  214.     outportb(DLM(), byte);
  215. }
  216.  
  217. void uart::SetLSR(char byte)
  218. {
  219.     outportb(LSR(), byte);
  220. }
  221.  
  222. void uart::SetMCR(char byte)
  223. {
  224.     outportb(MCR(), byte);
  225. }
  226.  
  227. void uart::SetMSR(char byte)
  228. {
  229.     outportb(MSR(), byte);
  230. }
  231.  
  232. void uart::SetTHR(char byte)
  233. {
  234.     outportb(THR(), byte);
  235. }
  236.  
  237. void uart::SetIER(char byte)
  238. {
  239.     outportb(IER(), byte);
  240. }
  241.  
  242. void uart::SetIER_Recieve(boolean bit)
  243. {
  244.     SetIER( (bit) ? GetIER() | 1 : GetIER() & (~1) );
  245. }
  246.  
  247. void uart::SetIER_Transmit(boolean bit)
  248. {
  249.     SetIER( (bit) ? GetIER() | 2 : GetIER() & (~2) );
  250. }
  251.  
  252. void uart::SetIER_Line(boolean bit)
  253. {
  254.     SetIER( (bit) ? GetIER() | 4 : GetIER() & (~4) );
  255. }
  256.  
  257. void uart::SetIER_Modem(boolean bit)
  258. {
  259.     SetIER( (bit) ? GetIER() | 8 : GetIER() & (~8) );
  260. }
  261.  
  262. void uart::SetLCR_DLAB(boolean bit)
  263. {
  264.     SetLCR( (bit) ? GetLCR() | 128 : GetLCR() & (~128) );
  265. }
  266.  
  267. void uart::SetLSR_DR(boolean bit)
  268. {
  269.     SetLSR( (bit) ? GetLSR() | 1 : GetLSR() & (~1) );
  270. }
  271.  
  272. void uart::SetBaudRate(int speed)
  273. {
  274.     int divisor = 115200L / speed;
  275.     char lsb = divisor & 0xFF;
  276.     char msb = (divisor >> 8) & 0xFF;
  277.     SetLCR_DLAB(true);        
  278.     SetDLL(lsb);
  279.     SetDLM(msb);
  280.     SetLCR_DLAB(false);
  281. }
  282.         
  283. int uart::GetBaudRate()
  284. {
  285.     SetLCR_DLAB(true);
  286.     int lsb = GetDLL() & 0xFF;    
  287.     int msb = GetDLM() & 0xFF;
  288.     SetLCR_DLAB(false);
  289.     return ( 115200L / ((msb << 8) + lsb) );
  290. }
  291.  
  292. void uart::SetParity(parity_t p)
  293. {
  294.     SetLCR( (GetLCR() & 0xC7) | p);
  295. }    
  296.  
  297. parity_t uart::GetParity()
  298. {
  299.     return (parity_t)(GetLCR() & 0x38);
  300. }
  301.  
  302. void uart::SetWordLength(int len)
  303. {
  304.     SetLCR( (GetLCR() & 0xFC) | ((len - 5) & 3) );
  305. }
  306.  
  307. int uart::GetWordLength()
  308. {
  309.     return (GetLCR() & 3) + 5;
  310. }
  311.  
  312. void uart::SetStopBits(int num)
  313. {
  314.     SetLCR( (GetLCR() & 0xFB) | ((num == 1) ? 0 : 4) );
  315. }
  316.  
  317. int uart::GetStopBits()
  318. {
  319.     return (GetLCR() & 4) ? 1 : 2;
  320. }
  321.  
  322. void uart::SetBreak()
  323. {
  324.     SetLCR(GetLCR() | 64);
  325. }
  326.  
  327. void uart::StopBreak()
  328. {
  329.     SetLCR(GetLCR() & (~64));
  330. }
  331.  
  332. void uart::Pause(int msec)
  333. {
  334.     // assumes the PC BIOS tick is 18.2 per second, or
  335.     // 55 msec per tick.
  336.     // DO NOT call this from an interrupt driver that uses the clock!
  337.     union REGS regs;
  338.     regs.x.ax = 0;
  339.     int86(0x1A, ®s, ®s);
  340.     int startcount = regs.x.dx;
  341.     int endcount = startcount + (msec / 55);
  342.     int i = startcount;
  343.     while(i < endcount && i >= startcount)
  344.     {
  345.         regs.x.ax = 0;
  346.         int86(0x1A, ®s, ®s);
  347.         i = regs.x.dx;
  348.     }
  349. }
  350.  
  351. void uart::Break(int msec)
  352. {
  353.     // assumes the PC BIOS tick is 18.2 per second, or
  354.     // 55 msec per tick.
  355.     // DO NOT call this from an interrupt driver that uses the clock!
  356.     SetBreak();
  357.     Pause(msec);
  358.     StopBreak();
  359. }
  360.  
  361. void uart::SetCTS(boolean bit)
  362. {
  363.     SetMSR( (bit) ? (GetMSR() | 16) : (GetMSR() & (~16)) );
  364. }
  365.  
  366. void uart::SetDSR(boolean bit)
  367. {
  368.     SetMSR( (bit) ? (GetMSR() | 32) : (GetMSR() & (~32)) );
  369. }
  370.  
  371. boolean uart::CarrierPresent()
  372. {
  373.     // actually tests RLSD, bit 7 of MSR.
  374.     return (GetMSR() & 128) ? true : false;
  375. }
  376.  
  377. void uart::SetDTR(boolean bit)
  378. {
  379.     SetMCR( (bit) ? (GetMCR() | 1) : (GetMCR() & (~1)) );
  380. }
  381.  
  382. boolean uart::GetDTR()
  383. {
  384.     return (GetMCR() & 1) ? true : false;
  385. }
  386.  
  387. com_interrupt_t uart::GetIntrType()
  388. {
  389.     int type = (int)GetIIR() & 0xFF;
  390.     if(type & 1)
  391.         return NONE_PENDING;
  392.     int r;
  393.     switch(type)
  394.     {
  395.         case 0:
  396.             r = GetMSR();
  397.             if(r & 4)
  398.                 return RING;
  399.             else if (r & 128)
  400.                 return CARRIER;
  401.             else 
  402.                 return NO_CARRIER;
  403.         case 2:
  404.             r = GetLSR();
  405.             if(r & 32)   // THRE
  406.                 return TRANSMIT_READY;
  407.             else 
  408.                 return TRANSMIT_FALSE_ALARM;
  409.         case 4:
  410.             return RECEIVE_READY;
  411.         case 6:
  412.             r = GetLSR();
  413.             if(r & 2)    // 
  414.                 return OVERRUN_ERROR;
  415.             else if(r & 4)
  416.                 return PARITY_ERROR;
  417.             else if(r & 8)
  418.                 return FRAMING_ERROR;
  419.             else if(r & 16)
  420.                 return BREAK_RECEIVED;
  421.             else 
  422.                 return UNKNOWN_ERROR;
  423.         default : 
  424.             return UNKNOWN_ERROR; 
  425.     }
  426. }
  427.  
  428.  
  429. int uart::GetChar()
  430. {
  431.     // note: for this method to work, SetLCR_DLAB(false) must be called.
  432.     return (GetLSR() & 1) ? ( (int)inportb(RBR()) & 0x00FF ) : -1;
  433. }
  434.  
  435. void uart:: SendChar(char ch)
  436. {   
  437.     // note: for this method to work, SetLCR_DLAB(false) must be called.
  438.     // this method works only if there is room in the transmit register.
  439.     outportb(THR(), ch);
  440. }
  441.  
  442. void uart::TransmitChar(char ch)
  443. {
  444.     // similar to last one -- allows other to be overloaded separately
  445.     outportb(THR(), ch);
  446. }
  447.  
  448. int uart::ReceiveChar()
  449. {
  450.     // similar to GetChar() -- allows other to be overloaded separately
  451.     // note: for this method to work, SetLCR_DLAB(false) must be called.
  452.     return (GetLSR() & 1) ? ( (int)inportb(RBR()) & 0x00FF ) : -1;    
  453. }
  454.